Closes modelcontextprotocol#5

Add a standalone sample project demonstrating the MCP Roots capability:

- Client declares roots capability with listChanged=true
- Client registers filesystem roots using addRoot()
- Server queries roots from client via listRoots()
- Client sends notifications/roots/list_changed after dynamic changes
- Server reacts to change notifications by re-fetching the root list

Uses ChannelTransport from kotlin-sdk-testing for in-memory
client-server communication without external dependencies.

- Remove Tools capability from server (not used in this demo)
- Use async instead of launch+CompletableDeferred in notification handler
  so the returned Deferred represents actual work completion
- Construct file URIs from System.getProperty('user.home') for
  cross-platform correctness (also ensures file:/// prefix)
- Apply null-safe name fallback consistently (?: '(unnamed)')

…c sync

- Add try/catch in notification handler to surface errors instead of
  silently dropping them
- Replace delay(500) with CompletableDeferred-based synchronization
  so the demo waits for the server to process each notification
  deterministically instead of relying on timing
- Close server before client to avoid Not connected errors

…-demo

The notification handler launches coroutines via  on Dispatchers.Default,
so the  increment was a data race — two coroutines could
read the same value and both write back 1, causing rootsUpdated to never complete.
Replaced with AtomicInteger.incrementAndGet() for thread-safe counting.

- Await each notification separately (firstNotification/secondNotification)
  before sending the next, so the server processes each state change
  before the client sends the next one
- Remove withTimeout(5000) that could throw TimeoutCancellationException
  and skip close() calls; now the main coroutine awaits each signal
  directly, so shutdown always runs
- Keep AtomicInteger for thread-safe notification counting

…s on errors

Move firstNotification/secondNotification completion into a finally block
so that even if listRoots() throws, the main coroutine does not hang
waiting on a CompletableDeferred that will never complete.

Strip back the over-engineered async coordination (AtomicInteger,
per-notification CompletableDeferred, withTimeoutOrNull, try/finally)
and replace with a clear, linear flow that demonstrates the Roots
lifecycle: declare capability, add roots, query, notify, react.

The demo now matches the simplicity of other SDK samples and the
integration tests. A short delay is used for notification propagation
which is appropriate for sample code — it prioritizes readability
over production-grade async patterns.

Key changes:
- Removed AtomicInteger counter and separate CompletableDeferred signals
- Removed withTimeoutOrNull (not needed for a demo)
- Removed try/finally on close (not needed — runBlocking handles cleanup)
- Restored hardcoded file:// URIs (matches MCP spec examples and
  other SDK samples)
- Added clear comments for each step in the Roots lifecycle
- Total: 82 lines, down from 108